package com.gitee.huanminabc.jcommon.reflect;

import java.math.BigDecimal;
import java.time.temporal.Temporal;
import java.time.temporal.TemporalAccessor;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

/**
 * @description:
 * @author: huanmin
 * @create: 2025-04-03 12:57
 **/
public class ClassIdentifyUtil {
    private static final Map<Class<?>, Class<?>> wrapperPrimitiveMap = new HashMap<>();
    static {
        wrapperPrimitiveMap.put(Boolean.class, Boolean.TYPE);
        wrapperPrimitiveMap.put(Byte.class, Byte.TYPE);
        wrapperPrimitiveMap.put(Character.class, Character.TYPE);
        wrapperPrimitiveMap.put(Short.class, Short.TYPE);
        wrapperPrimitiveMap.put(Integer.class, Integer.TYPE);
        wrapperPrimitiveMap.put(Long.class, Long.TYPE);
        wrapperPrimitiveMap.put(Double.class, Double.TYPE);
        wrapperPrimitiveMap.put(Float.class, Float.TYPE);
    }

    //判断是否是基本类型
    public static boolean isPrimitive(final Class<?> type) {
        return wrapperPrimitiveMap.containsKey(type);
    }
    //判断是否是基本类型或者包装类型
    public static boolean isPrimitiveOrWrapper(final Class<?> type) {
        if (type == null) {
            return false;
        }
        return type.isPrimitive() || isPrimitive(type);
    }
    //判断是否是基本类型或者包装类型或字符串
    public static boolean isPrimitiveOrWrapperOrString(final Class<?> type) {
        if (type == null) {
            return false;
        }
        return type.isPrimitive() || isPrimitive(type)|| String.class.isAssignableFrom(type) ;
    }


    //是基本类型
    public static boolean isBaseType(Class<?> type) {
        return isPrimitiveOrWrapper(type) ||
                String.class.isAssignableFrom(type) ||
                Date.class.isAssignableFrom(type);
    }

    // 最常用的类型而且都是内置的通用类型
    // - 基本类型或者包装类型
    // - String类型
    // - 时间类型
    // - 枚举
    public static boolean isInlayGeneralType(final Class<?> type) {
        if (type == null) {
            return false;
        }
        if (isPrimitiveOrWrapper(type)) {
            return true;
        }
        if (String.class.isAssignableFrom(type)) {
            return true;
        }
        if (Temporal.class.isAssignableFrom(type)||Date.class.isAssignableFrom(type)) {
            return true;
        }
        if (BigDecimal.class.isAssignableFrom(type)) { // 检查 BigDecimal 类型
            return true;
        }
        // 检查枚举类型
        if (type.isEnum()) {
            return true;
        }
        return false;
    }



    /**
     * 判断一个对象是否为数组
     *
     * @param c
     * @return
     */
    public static boolean isArray(Class c) {
        return c != null && c.isArray();
    }

    /**
     * 判断一个是否为基本类型数组即(int[], long[], boolean[], double[]....)
     * 这个是可以区分出来的, 如果传入的是包装那么就返回false
     * @param c
     * @return
     */
    public static boolean isPrimitiveArray(Class c) {
        return isArray(c) && c.getComponentType().isPrimitive();
    }


    public static boolean isCollection(Class c) {
        return c != null && Collection.class.isAssignableFrom(c);
    }

    public static boolean isMap(Class c) {
        return  c != null && Map.class.isAssignableFrom(c);
    }

    public static boolean isNumber(Class c) {
        return   c != null && Number.class.isAssignableFrom(c);
    }

    public static boolean isBoolean(Class c) {
        return  c != null && Boolean.class.isAssignableFrom(c);
    }

    public static boolean isEnum(Class obj) {
        return  obj != null && obj.isEnum();
    }

    public static boolean isDate(Class c) {
        return c != null && (Date.class.isAssignableFrom(c) || TemporalAccessor.class.isAssignableFrom(c));
    }
    public static boolean isCharSequence(Class c) {
        return  c != null && CharSequence.class.isAssignableFrom(c);
    }
}
